{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:22.871410Z",
     "start_time": "2025-02-11T05:31:22.866774Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 41
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1 特征中含有字符串的时候（当成类别），如何做特征抽取"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=True)  # 把sparse改为True看看\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                               {'city': '上海', 'temperature': 60},\n",
    "                               {'city': '深圳', 'temperature': 30}])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:22.991575Z",
     "start_time": "2025-02-11T05:31:22.982704Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Compressed Sparse Row sparse matrix of dtype 'float64'\n",
      "\twith 6 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t1.0\n",
      "  (0, 3)\t100.0\n",
      "  (1, 0)\t1.0\n",
      "  (1, 3)\t60.0\n",
      "  (2, 2)\t1.0\n",
      "  (2, 3)\t30.0\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': 1.0, 'temperature': 100.0}, {'city=上海': 1.0, 'temperature': 60.0}, {'city=深圳': 1.0, 'temperature': 30.0}]\n"
     ]
    }
   ],
   "execution_count": 42
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 一段英文文本如何变为数值类型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(res)\n",
    "    print('-'*50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-'*50)\n",
    "    print(res.toarray()) #稀疏矩阵转换为数组\n",
    "    print('-'*50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.019861Z",
     "start_time": "2025-02-11T05:31:23.010767Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 43
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我 喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(data) #稀疏存储，只记录非零位置\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.066754Z",
     "start_time": "2025-02-11T05:31:23.059975Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 44
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword() #jieba分词好的中文文本\n",
    "    print('-'*50)\n",
    "    print(c1)\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-'*50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "# cutword()\n",
    "hanzivec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.096511Z",
     "start_time": "2025-02-11T05:31:23.086918Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 45
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1.4 tf-idf"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(type(data))\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.164237Z",
     "start_time": "2025-02-11T05:31:23.154432Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 46
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 特征处理，不同的特征拉到到同一个量纲"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print('-'*50)\n",
    "    out=mm.transform([[1, 2, 3, 4],[6, 5, 8, 7]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.189375Z",
     "start_time": "2025-02-11T05:31:23.181461Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 47
  },
  {
   "cell_type": "code",
   "source": [
    "(1-60)/30"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.250837Z",
     "start_time": "2025-02-11T05:31:23.245268Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.9666666666666666"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 48
  },
  {
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.], [2., 4., 2.], [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data=stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.280096Z",
     "start_time": "2025-02-11T05:31:23.271555Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 49
  },
  {
   "cell_type": "code",
   "source": [
    "type(data)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.330697Z",
     "start_time": "2025-02-11T05:31:23.326247Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 50
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform(data)\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.387915Z",
     "start_time": "2025-02-11T05:31:23.382400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.48029737e-16  7.40148683e-17  7.40148683e-17]\n",
      "[1. 1. 1.]\n"
     ]
    }
   ],
   "execution_count": 51
  },
  {
   "cell_type": "code",
   "source": [
    "(np.square(1-2.333)+np.square(2-2.333)+np.square(4-2.333))/3"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.445303Z",
     "start_time": "2025-02-11T05:31:23.439897Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5555556666666668"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 52
  },
  {
   "cell_type": "code",
   "source": [
    "(1-2.333)/np.sqrt(1.55555)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.497141Z",
     "start_time": "2025-02-11T05:31:23.490601Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.068779614944516"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 53
  },
  {
   "cell_type": "markdown",
   "source": [
    "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:NOne\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.559036Z",
     "start_time": "2025-02-11T05:31:23.550602Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 54
  },
  {
   "cell_type": "code",
   "source": [
    "11/3"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.596254Z",
     "start_time": "2025-02-11T05:31:23.590948Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.6666666666666665"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 55
  },
  {
   "cell_type": "code",
   "source": [
    "np.nan+10"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.640963Z",
     "start_time": "2025-02-11T05:31:23.635024Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 56
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（模型的参数减少了）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.685826Z",
     "start_time": "2025-02-11T05:31:23.678657Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 57
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5], [6, 3, 0, 8], [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum()) #最初数据的方差\n",
    "    print('-'* 50)\n",
    "    pca = PCA(n_components=0.9)\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-'*50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.727823Z",
     "start_time": "2025-02-11T05:31:23.719635Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 58
  },
  {
   "cell_type": "code",
   "source": [
    "22/29.333333333333336"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.748895Z",
     "start_time": "2025-02-11T05:31:23.743785Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7499999999999999"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 59
  },
  {
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "x = np.random.rand(10000) #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t,x,'g.',label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-11T05:31:23.981731Z",
     "start_time": "2025-02-11T05:31:23.802125Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 60
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
